\documentclass[hyperref={pdfpagelabels=false}]{beamer}

% Pacotes Utilizados -----------------------------------------------------------
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[brazil]{babel}

% Configurações Genéricas ------------------------------------------------------
\let\Tiny=\tiny

% Configurações Específicas ----------------------------------------------------
\setbeamertemplate{navigation symbols}{}

% Dados Pessoais ---------------------------------------------------------------
\title{Happy}
\subtitle{Parser Generator System for Haskell}
\author[ROSA]{Wanderson Henrique Camargo Rosa\and{}Roberto Raguze Flores}
\institute[UNISINOS]{Centro de Ciências Exatas e Tecnológicas\\Universidade do
Vale do Rio dos Sinos}
\date{São Leopoldo, Novembro de 2010}
\keywords{compilador sintaxe happy haskell}

% Documento --------------------------------------------------------------------
\begin{document}

% Apresentação -----------------------------------------------------------------
\begin{frame}
    \maketitle{}
\end{frame}

% Conteúdo ---------------------------------------------------------------------
\begin{frame}
    \tableofcontents{}
\end{frame}

% Seção: Introdução ------------------------------------------------------------
\section{Introdução}

\begin{frame}{Happy}{Parser Generator System for Haskell}
    \begin{block}{Happy}
        Sistema gerador de \textit{parsers} para Haskell que recebe um arquivo
        contendo uma especificação BNF de uma gramática e produz um módulo em
        Haskell contendo o \textit{parser} para a gramática\cite{marlow2009}.
    \end{block}
\end{frame}

\begin{frame}{Happy}{Características}
    \begin{itemize}
        \item Programação Funcional
        \item Rápido
        \begin{itemize}
            \item Comparado com Ferramentas Similares
            \item Glasgow Haskell Compiler (GHC)
        \end{itemize}
        \item \textit{Lazy Evaluation}
        \item Estrutura de Arquivo Yacc
        \item LALR(1) e GLR
    \end{itemize}
\end{frame}

% Seção: Exemplo ---------------------------------------------------------------
\section{Exemplo}

\begin{frame}[fragile]{Exemplo}{Cabeçalho}
\begin{verbatim}
{
module Main where
import Data.Char
}

%name calc
%tokentype { Token }
%error { parserError }
\end{verbatim}
\end{frame}

\begin{frame}[fragile]{Exemplo}{\textit{Tokens} e Associatividade}
\begin{verbatim}
%token
    let { TokenLet }
    in  { TokenIn }
    int { TokenInt $$ }
    var { TokenVar $$ }
    '=' { TokenEq }
    '+' { TokenPlus }
    '-' { TokenMinus }
    '*' { TokenTimes }
    '/' { TokenDiv }
    '(' { TokenOB }
    ')' { TokenCB }

%right in
%left '+' '-'
%left '*' '/'
\end{verbatim}
\end{frame}

\begin{frame}[fragile]{Exemplo}{Produções}
\begin{verbatim}
%%

Exp
    : let var '=' Exp in Exp { Let $2 $4 $6 }
    | Exp '+' Exp { Plus $1 $3 }
    | Exp '-' Exp { Minus $1 $3 }
    | Exp '*' Exp { Times $1 $3 }
    | Exp '/' Exp { Div $1 $3 }
    | '(' Exp ')' { Brack $2 }
    | int { Int $1 }
    | var { Var $1 } 
\end{verbatim}
\end{frame}

\begin{frame}[fragile]{Exemplo}{Tratamento de Erros e Estrutura de Dados}
\begin{verbatim}
{
parserError :: [Token] -> a
parserError _ = error "ParseError"

data Exp
    = Let String Exp Exp
    | Plus Exp Exp
    | Minus Exp Exp
    | Times Exp Exp
    | Div Exp Exp
    | Int Int
    | Var String
    | Brack Exp
    deriving Show
\end{verbatim}
\end{frame}

\begin{frame}[fragile]{Exemplo}{Estrutura de Dados para \textit{Tokens}}
\begin{verbatim}
data Token
    = TokenLet
    | TokenIn
    | TokenInt Int
    | TokenVar String
    | TokenEq
    | TokenPlus
    | TokenMinus
    | TokenTimes
    | TokenDiv
    | TokenOB
    | TokenCB
    deriving Show
\end{verbatim}
\end{frame}

\begin{frame}[fragile]{Exemplo}{Analisador Léxico Opcional}
\begin{verbatim}
lexer :: String -> [Token]
lexer [] = []
lexer(c:cs)
    | isSpace c = lexer cs
    | isAlpha c = lexVar (c:cs)
    | isDigit c = lexNum (c:cs)

lexer ('=':cs) = TokenEq : lexer cs
lexer ('+':cs) = TokenPlus : lexer cs
lexer ('-':cs) = TokenMinus : lexer cs
lexer ('*':cs) = TokenTimes : lexer cs
lexer ('/':cs) = TokenDiv : lexer cs
lexer ('(':cs) = TokenOB : lexer cs
lexer (')':cs) = TokenCB : lexer cs
\end{verbatim}
\end{frame}

\begin{frame}[fragile]{Exemplo}{Analisador Léxico Opcional}
\begin{verbatim}
lexNum cs = TokenInt (read num) : lexer rest
    where (num,rest) = span isDigit cs

lexVar cs =
    case span isAlpha cs of
        ("let",rest) -> TokenLet : lexer rest
        ("in",rest) -> TokenIn : lexer rest
        (var,rest) -> TokenVar var : lexer rest

main = getContents >>= print . calc . lexer
}
\end{verbatim}
\end{frame}

\begin{frame}[fragile]{Exemplo}{Arquivo Fonte e Compilador ou Interpretador}
\begin{verbatim}
happy example.y -i -g -d -o"output.out"
    -i info
    -g Glasgow Haskell Compiler Directives
    -d Debug
    -o Output File

ghc example.hs
hugs example.hs

\end{verbatim}
\end{frame}

\begin{frame}[fragile]{Exemplo}{Entrada e Saída Geradas}
\begin{verbatim}
1+1
Plus (Int 1) (Int 1)

1+2*3
Plus (Int 1) (Times (Int 2) (Int 3))

1*2+3
Plus (Times (Int 1) (Int 2)) (Int 3)
\end{verbatim}
\end{frame}

% Seção: Áreas de Aplicação ----------------------------------------------------
\section{Áreas de Aplicação}

\begin{frame}{Áreas de Aplicação}
    \begin{itemize}
        \item Glasgow Haskell Compiler\cite{marlow2009}
        \item Documentação da Linguagem Haskell\cite{marlow2002}
        \item Desenvolvimento de Linguagens Naturais\cite{frost2006}
        \item Geradores de Programas\cite{erwig2005}
    \end{itemize}
\end{frame}

% Seção: Curiosidades ----------------------------------------------------------
\section{Curiosidades}

\begin{frame}[fragile]{Curiosidades}
    \begin{itemize}
        \item Usar sempre que possível recursão à esquerda, diminuindo a pilha
        do analisador sintático; e
        \item Não possui sequenciadores estilo \verb|n+| ou \verb|n*|.
    \end{itemize}
\end{frame}

% Seção: Referências Bibliográficas --------------------------------------------
\section{Referências}

\begin{frame}{Referências}
    \bibliography{document}
    \bibliographystyle{plain}
\end{frame}

\end{document}